package cn.demo.d01;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
import java.util.StringJoiner;

public class Demo08 {
    public static void main(String[] args) {
        // test51();
        // System.out.println("---------------------------");
        // test52();
        // System.out.println("---------------------------");
        // test53();
        // System.out.println("---------------------------");
        // test54();
        // System.out.println("---------------------------");
        // test55();
        // System.out.println("---------------------------");
        // test56();
        // System.out.println("---------------------------");
        // test57();
        // System.out.println("---------------------------");
        test58();
        System.out.println("---------------------------");
    }

    /*
    需求： 键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是
    * */
    private static void test51() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串: ");
        String str = sc.next();
        String reverseStr = new StringBuilder(str).reverse().toString();
        if (str.equals(reverseStr)){
            System.out.println("是对称字符串");
        }else{
            System.out.println("不是对称字符串");
        }
    }

    /*
    需求：定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回。
         调用该方法，并在控制台输出结果。
    例如：数组为int[] arr = {1,2,3};
         执行方法后的输出结果为：[1, 2, 3]
    * */
    private static void test52() {
        int[] arr = {1,2,3};
        StringJoiner sj = new StringJoiner(", ", "<", ">");
        for (int i = 0; i < arr.length; i++) {
            sj.add(arr[i]+"");
        }
        System.out.println(sj);
    }

    /* 键盘录入一个字符串，
        要求1：长度为小于等于9
        要求2：只能是数字
                将内容变成罗马数字
        下面是阿拉伯数字跟罗马数字的对比关系：
        Ⅰ－1、Ⅱ－2、Ⅲ－3、Ⅳ－4、Ⅴ－5、Ⅵ－6、Ⅶ－7、Ⅷ－8、Ⅸ－9
        注意点：
        罗马数字里面是没有0的
        如果键盘录入的数字包含0，可以变成""(长度为0的字符串)*/
    private static void test53() {
        //1.键盘录入一个字符串
        //书写Scanner的代码
        Scanner sc = new Scanner(System.in);
        String str;
        while (true) {
            System.out.println("请输入一个字符串");
            str = sc.next();
            //2.校验字符串是否满足规则
            boolean flag = checkStr(str);
            if (flag) {
                break;
            }
            System.out.println("当前的字符串不符合规则，请重新输入");
        }
        //将内容变成罗马数字
        //下面是阿拉伯数字跟罗马数字的对比关系：
        //Ⅰ－1、Ⅱ－2、Ⅲ－3、Ⅳ－4、Ⅴ－5、Ⅵ－6、Ⅶ－7、Ⅷ－8、Ⅸ－9
        //查表法：数字跟数据产生一个对应关系
        StringBuilder sb = new StringBuilder();
        StringBuilder sb2 = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            int number = str.charAt(i)-'0';
            sb.append(changeLuoMa(number));
            sb2.append(changeLuoMa(str.charAt(i)));
        }
        System.out.println(sb);
        System.out.println(sb2);
    }

    public static String changeLuoMa(char num) {
        return switch (num){
            case '1' -> "Ⅰ";
            case '2' -> "Ⅱ";
            case '3' -> "Ⅲ";
            case '4' -> "Ⅳ";
            case '5' -> "Ⅴ";
            case '6' -> "Ⅵ";
            case '7' -> "Ⅶ";
            case '8' -> "Ⅷ";
            case '9' -> "Ⅸ";
            default ->  "";
        };
    }

    public static String changeLuoMa(int number) {
        //定义一个数组，让索引跟罗马数字产生一个对应关系
        String[] arr = {"", "Ⅰ", "Ⅱ", "Ⅲ", "Ⅳ", "Ⅴ", "Ⅵ", "Ⅶ", "Ⅷ", "Ⅸ"};
        return arr[number];
    }

    private static boolean checkStr(String str) {
        //要求1：长度为小于等于9
        if (str.length() > 9) {
            return false;
        }

        //要求2：只能是数字
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);//0~9
            if (c < '0' || c > '9') {
                return false;
            }
        }

        //只有当字符串里面所有的字符全都判断完毕了，我才能认为当前的字符串是符合规则
        return true;
    }

    /* 给定两个字符串, A和B。
        A的旋转操作就是将A 最左边的字符移动到最右边。
        例如, 若A = 'abcde'，在移动一次之后结果就是'bcdea'
        如果在若干次调整操作之后，A能变成B，那么返回True。
        如果不能匹配成功，则返回false*/
    private static void test54(){
        String strA = "abcde";
        String strB = "cdeab";
        for (int i = 0; i < strA.length(); i++) {
            // strA = rotate(strA);
            strA = rotate2(strA);
            if (strA.equals(strB)){
                System.out.println("可以旋转!");
                return;
            }
        }
        System.out.println("不可以旋转");
    }

    private static String rotate2(String str){
        char[] charArray = str.toCharArray();
        char first = charArray[0];
        for (int i = 1; i < charArray.length; i++) {
            charArray[i-1] = charArray[i];
        }
        charArray[charArray.length-1] = first;
        return String.valueOf(charArray);
    }

    private static String rotate(String str){
        String begin = str.substring(0,1);
        return str.substring(1) + begin;
    }

    /*
    键盘输入任意字符串，打乱里面的内容
    * */
    private static void test55(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串: ");
        String str = sc.next();
        char[] chars = str.toCharArray();
        Random r = new Random();
        for (int i = 0; i < chars.length; i++) {
            int index = r.nextInt(chars.length);
            if (index == i){
                continue;
            }
            char temp = chars[index];
            chars[index] = chars[i];
            chars[i] = temp;
        }
        System.out.println(str);
        System.out.println(String.valueOf(chars));
    }

    /*
        生成验证码
        内容：可以是小写字母，也可以是大写字母，还可以是数字
        规则：
        长度为5
        内容中是四位字母，1位数字。
        其中数字只有1位，但是可以出现在任意的位置。*/
    private static void test56(){
        // 1.可以把所有的大写字母，小写字母都放到一个数组当中
        char[] chars = new char[52];
        int i = 0;
        for (; i < chars.length/2; i++) {
            chars[i] = (char)('a'+i);
        }
        for (char c='A';c<='Z';c++) {
            chars[i] = c;
            i++;
        }
        StringBuilder sb = new StringBuilder();
        Random r = new Random();
        for (int j = 0; j <4; j++) {
            sb.append(chars[r.nextInt(chars.length)]);
        }
        sb.append(r.nextInt(10));
        char[] chars1 = sb.toString().toCharArray();
        for (int i1 = 0; i1 < chars1.length; i1++) {
            int index = r.nextInt(chars1.length);
            if (index == i1){
                continue;
            }
            char temp = chars1[index];
            chars1[index] = chars1[i1];
            chars1[i1] = temp;
        }
        System.out.println(sb);
        System.out.println(String.valueOf(chars1));
    }

    /* 给定两个以字符串形式表示的非负整数num1和num2，返回num1和num2的乘积，它们的乘积也表示为字符串形式。
        注意：需要用已有的知识完成。*/
    private static void test57(){
        //不需要考虑乘积过大之后的结果
        //就认为乘积一定是小于int的最大值的
        String numStr1 = "123";
        String numStr2 = "321";
        int resultNum1 = strToInt(numStr1);
        int resultNum2 = strToInt(numStr2);
        System.out.println(resultNum1+"*"+resultNum2+"="+(resultNum1*resultNum2));
    }

    private static int strToInt(String numStr1) {
        int resultNum1 = 0;
        for (int i = 0; i < numStr1.length(); i++) {
            char c = numStr1.charAt(i);
            resultNum1 = resultNum1 * 10 + (c - '0');
        }
        return resultNum1;
    }

    /* 给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。
        返回字符串中最后一个单词的长度。
        单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

        示例 1：输入：s = "Hello World“	输出：5
        解释：最后一个单词是“World”，长度为5。

        示例 2：输入：s = "   fly me   to   the moon"	输出：4
        解释：最后一个单词是“moon”，长度为4。

        示例 3：输入：s = "luffy is still joyboy"	输出：6
        解释：最后一个单词是长度为6的“joyboy”。*/
    private static void test58(){
        //倒着遍历
        //直到遇到空格为止

        //那么遍历的次数就是单词的长度
        String str = "hello world diaomao";
        int count = 0;
        int index = 0;
        for (int i = str.length()-1; i >=0 ; i--) {
            char c = str.charAt(i);
            if (Character.isSpaceChar(c)){
                index = i;
                break;
            }
            count++;
        }
        System.out.println("返回字符串中最后一个单词"+str.substring(index)+"的长度是:"+count+"。");
    }
}
